.TH std::function_ref::function_ref 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::function_ref::function_ref \- std::function_ref::function_ref

.SH Synopsis
   template< class F >                                        \fB(1)\fP (since C++26)
   function_ref( F* f ) noexcept;
   template< class F >                                        \fB(2)\fP (since C++26)
   function_ref( F&& f ) noexcept;
   template< auto f >                                         \fB(3)\fP (since C++26)
   function_ref( std::nontype_t<f> ) noexcept;
   template< auto f, class U >                                \fB(4)\fP (since C++26)
   function_ref( std::nontype_t<f>, U&& obj ) noexcept;
   template< auto f, class T >                                \fB(5)\fP (since C++26)
   function_ref( std::nontype_t<f>, /*cv*/ T* obj ) noexcept;
   function_ref( const function_ref& other ) = default;       \fB(6)\fP (since C++26)

   Creates a new std::function_ref.

   1) Initializes bound-entity with f, and thunk-ptr with the address of a function
   thunk. The behavior is undefined if f is a null pointer.
     * This overload participates in overload resolution only if both
       std::is_function_v<F> and /*is-invocable-using*/<F> are true.
   2) Initializes bound-entity with std::addressof(f), and thunk-ptr with the address
   of a function thunk.
     * Let T be std::remove_reference_t<F>. This overload participates in overload
       resolution only if :
          * std::remove_cvref_t<F> is not the same type as function_ref,
          * std::is_member_pointer_v<T> is false, and
          * /*is-invocable-using*/</*cv*/ T&> is true.
   3) Initializes bound-entity with a pointer to an unspecified object or null pointer
   value, and thunk-ptr with the address of a function thunk.
     * Let F be decltype(f). This overload participates in overload resolution only if
       /*is-invocable-using*/<F> is true.
     * The program is ill-formed if f != nullptr is false when std::is_pointer_v<F> ||
       std::is_member_pointer_v<F> is true.
   4) Initializes bound-entity with std::addressof(obj), and thunk-ptr with the address
   of a function thunk.
     * Let T be std::remove_reference_t<U> and F be decltype(f). This overload
       participates in overload resolution only if :
          * std::is_rvalue_reference_v<U&&> is false, and
          * /*is-invocable-using*/<F, /*cv*/ T&> is true.
     * The program is ill-formed if f != nullptr is false when std::is_pointer_v<F> ||
       std::is_member_pointer_v<F> is true.
   5) Initializes bound-entity with obj, and thunk-ptr with the address of a function
   thunk. The behavior is undefined if obj is a null pointer when
   std::is_member_pointer_v<F> is true.
     * Let F be decltype(f). This overload participates in overload resolution only if
       /*is-invocable-using*/<F, /*cv*/ T*> is true.
     * The program is ill-formed if f != nullptr is false when std::is_pointer_v<F> ||
       std::is_member_pointer_v<F> is true.
   6) Defaulted copy constructor copies the bound-entity and thunk-ptr of other.

   The address of a function thunk is used to initialize thunk-ptr such that a call to
   thunk(bound-entity, call-args...) is expression-equivalent to:

   Overloads                   Expression-equivalence
     (1,3)   std::invoke_r<R>(f, call-args...)
      \fB(2)\fP    std::invoke_r<R>(static_cast<cv T&>(f), call-args...)
      \fB(4)\fP    std::invoke_r<R>(f, static_cast<cv T&>(obj), call-args...)
      \fB(5)\fP    std::invoke_r<R>(f, obj, call-args...)

   /*is-invocable-using*/<T...> is true if and only if:

     * std::is_nothrow_invocable_r_v<R, T..., Args...> is true if noex is true, or
     * std::is_invocable_r_v<R, T..., Args...> is true

.SH Parameters

   other - another function_ref to copy from
   f     - a function or a Callable object to wrap
   obj   - an object or pointer to bound

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

   constructor   constructs a new std::move_only_function object
   (C++23)       \fI(public member function of std::move_only_function)\fP

.SH Category:
     * Todo no example
